import fs from 'fs'
import path from 'path'
import { fileURLToPath } from 'url'

const __dirname = path.dirname(fileURLToPath(import.meta.url))

export default function versionUpdatePlugin(options = {}) {
  const {
    versionFile = 'version.json',
    checkInterval = 300000, // 5分钟检查一次
    alertMessage = '发现新版本可用，请刷新页面获取最新内容。',
    autoReload = false,
    storageKey = 'app_version_info'
  } = options

  return {
    name: 'version-update-plugin',
    apply: 'build',

    // 在构建完成后生成版本文件
    async writeBundle() {
      const outDir = 'dist'
      const versionFilePath = path.resolve(__dirname, `../${outDir}/${versionFile}`)
      
      const versionData = {
        version: Date.now(), // 使用时间戳作为版本号
        buildTime: new Date().toISOString(),
        buildDate: new Date().toLocaleString('zh-CN')
      }

      try {
        // 确保目录存在
        const dir = path.dirname(versionFilePath)
        if (!fs.existsSync(dir)) {
          fs.mkdirSync(dir, { recursive: true })
        }

        await fs.promises.writeFile(
          versionFilePath,
          JSON.stringify(versionData, null, 2),
          'utf-8'
        )
        console.log(`[version-update-plugin] 📦 版本文件已生成: v${versionData.version}`)
      } catch (error) {
        console.error('❌ 版本文件生成失败:', error.message)
      }
    },

    // 向HTML注入版本检查代码
    transformIndexHtml(html) {
      const versionScript = `
<!-- 版本更新检查 -->
<script>
(function() {
  const STORAGE_KEY = '${storageKey}';
  let checkTimer = null;
  let isChecking = false;

  // 初始化版本检查
  function initVersionCheck() {
    // 从localStorage获取保存的版本信息
    const savedVersion = getSavedVersion();
    
    // 首次加载立即检查版本
    checkForUpdate(savedVersion).then(data => {
      if (data) {
        // 保存当前版本到localStorage
        saveVersion(data.version);
        console.log('📦 当前版本:', data.version);
        
        // 开始定期检查
        startPeriodicCheck();
        
        // 监听事件
        document.addEventListener('visibilitychange', handleVisibilityChange);
        window.addEventListener('online', handleOnline);
      }
    }).catch(console.error);
  }

  // 从localStorage获取保存的版本
  function getSavedVersion() {
    try {
      const saved = localStorage.getItem(STORAGE_KEY);
      return saved ? JSON.parse(saved) : null;
    } catch (error) {
      console.warn('读取保存的版本信息失败:', error);
      return null;
    }
  }

  // 保存版本到localStorage
  function saveVersion(version) {
    try {
      localStorage.setItem(STORAGE_KEY, JSON.stringify({
        version: version,
        lastCheck: Date.now()
      }));
    } catch (error) {
      console.warn('保存版本信息失败:', error);
    }
  }

  // 获取最新版本信息
  async function fetchVersion() {
    try {
      const response = await fetch('${versionFile}?t=' + Date.now(), {
        cache: 'no-cache',
        headers: {
          'Cache-Control': 'no-cache',
          'Pragma': 'no-cache'
        }
      });
      if (!response.ok) throw new Error('网络响应异常');
      return await response.json();
    } catch (error) {
      console.warn('⚠️ 获取版本信息失败:', error.message);
      return null;
    }
  }

  // 检查版本更新
  async function checkForUpdate(savedVersionInfo = null) {
    if (isChecking) return;
    isChecking = true;

    try {
      const newData = await fetchVersion();
      if (!newData) return null;

      // 如果没有传入保存的版本信息，就从localStorage读取
      const savedVersion = savedVersionInfo || getSavedVersion();
      const currentVersion = savedVersion ? savedVersion.version : null;

      if (currentVersion && newData.version !== currentVersion) {
        console.log('🆕 发现新版本:', newData.version, '当前版本:', currentVersion);
        showUpdateNotification(newData);
      }

      return newData;
    } catch (error) {
      console.warn('版本检查失败:', error.message);
      return null;
    } finally {
      isChecking = false;
    }
  }

  // 显示更新通知
  function showUpdateNotification(versionData) {
    // 移除现有的通知
    const existingNotice = document.getElementById('version-update-notice');
    if (existingNotice) {
      existingNotice.remove();
    }

    const notice = document.createElement('div');
    notice.id = 'version-update-notice';
    notice.style = \`
      position: fixed;
      top: 20px;
      right: 20px;
      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
      color: white;
      padding: 16px 20px;
      border-radius: 8px;
      box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
      z-index: 10000;
      max-width: 320px;
      font-family: -apple-system, BlinkMacSystemFont, sans-serif;
      animation: slideIn 0.3s ease;
    \`;

    notice.innerHTML = \`
      <div style="display: flex; align-items: center; margin-bottom: 8px;">
        <span style="font-size: 18px; margin-right: 8px;">🔄</span>
        <strong style="font-size: 14px;">发现新版本</strong>
      </div>
      <div style="font-size: 12px; opacity: 0.9; margin-bottom: 8px;">
        ${alertMessage}
      </div>
      <div style="font-size: 11px; opacity: 0.7; margin-bottom: 12px;">
        构建时间: \${new Date(versionData.buildTime).toLocaleString('zh-CN')}
      </div>
      <div style="display: flex; gap: 8px;">
        <button onclick="handleUpdateAction()" style="
          background: rgba(255, 255, 255, 0.2);
          border: 1px solid rgba(255, 255, 255, 0.3);
          color: white;
          padding: 8px 16px;
          border-radius: 4px;
          cursor: pointer;
          font-size: 12px;
          backdrop-filter: blur(10px);
          flex: 1;
        ">立即刷新</button>
        <button onclick="this.parentElement.parentElement.remove()" style="
          background: transparent;
          border: 1px solid rgba(255, 255, 255, 0.3);
          color: white;
          padding: 8px 12px;
          border-radius: 4px;
          cursor: pointer;
          font-size: 12px;
          backdrop-filter: blur(10px);
        ">稍后</button>
      </div>
    \`;

    document.body.appendChild(notice);

    // 添加动画样式
    if (!document.getElementById('version-update-styles')) {
      const style = document.createElement('style');
      style.id = 'version-update-styles';
      style.textContent = \`
        @keyframes slideIn {
          from {
            transform: translateX(100%);
            opacity: 0;
          }
          to {
            transform: translateX(0);
            opacity: 1;
          }
        }
        #version-update-notice {
          transition: all 0.3s ease;
        }
        #version-update-notice:hover {
          transform: translateY(-2px);
          box-shadow: 0 6px 25px rgba(0, 0, 0, 0.2);
        }
      \`;
      document.head.appendChild(style);
    }

    // 30秒后自动消失
    setTimeout(() => {
      if (notice.parentElement) {
        notice.style.opacity = '0';
        setTimeout(() => notice.remove(), 300);
      }
    }, 30000);
  }

  // 处理更新操作
  window.handleUpdateAction = function() {
    if (${autoReload}) {
      window.location.reload();
    } else {
      if (confirm('确定要刷新页面获取最新版本吗？')) {
        window.location.reload();
      }
    }
  }

  // 开始定期检查
  function startPeriodicCheck() {
    if (checkTimer) clearInterval(checkTimer);
    checkTimer = setInterval(() => checkForUpdate(), ${checkInterval});
    console.log('⏰ 版本检查已启动');
  }

  // 页面可见性变化处理
  function handleVisibilityChange() {
    if (!document.hidden) {
      checkForUpdate();
    }
  }

  // 网络恢复时检查
  function handleOnline() {
    checkForUpdate();
  }

  // 页面加载完成后初始化
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', initVersionCheck);
  } else {
    initVersionCheck();
  }

  // 导出检查函数供手动调用
  window.checkVersionUpdate = () => checkForUpdate();
})();
</script>
`;

      return html.replace('</body>', `${versionScript}</body>`);
    }
  };
}